{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "4c722186",
   "metadata": {},
   "source": [
    "# IndRNN-LSTM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "91934c24",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "使用设备: cuda\n",
      "正在加载和处理数据...\n",
      "数据形状: (635729, 14)\n",
      "列名: ['StockCode', 'Date', 'Open', 'Close', 'High', 'Low', 'Volume', 'Turnover', 'Amplitude', 'PriceChange', 'TurnoverRate', 'year', 'month', 'day']\n",
      "股票数量: 300\n",
      "数据形状: (635729, 14)\n",
      "列名: ['StockCode', 'Date', 'Open', 'Close', 'High', 'Low', 'Volume', 'Turnover', 'Amplitude', 'PriceChange', 'TurnoverRate', 'year', 'month', 'day']\n",
      "股票数量: 300\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import pickle\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import TensorDataset, DataLoader\n",
    "from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from config import *\n",
    "\n",
    "# 设置随机种子\n",
    "torch.manual_seed(42)\n",
    "np.random.seed(42)\n",
    "\n",
    "# 设备配置\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(f\"使用设备: {device}\")\n",
    "\n",
    "\n",
    "def inputdata(path):\n",
    "    \"\"\"读取CSV数据文件\"\"\"\n",
    "    data = pd.read_csv(path, header=0, sep=\",\", encoding=\"utf-8\")\n",
    "    return data\n",
    "\n",
    "\n",
    "def transcolname(df, column_mapping):\n",
    "    \"\"\"转换列名为英文\"\"\"\n",
    "    df.rename(columns=column_mapping, inplace=True)\n",
    "    return df\n",
    "\n",
    "\n",
    "def trans_datetime(df):\n",
    "    \"\"\"日期时间特征转换\"\"\"\n",
    "    ret_df = pd.DataFrame()\n",
    "    dt = df[\"Date\"]\n",
    "\n",
    "    # 提取年月日特征\n",
    "    ret_df[\"year\"] = dt.transform(lambda x: int(x.split(\"-\")[0]))\n",
    "    ret_df[\"month\"] = dt.transform(lambda x: int(x.split(\"-\")[1]))\n",
    "    ret_df[\"day\"] = dt.transform(lambda x: int(x.split(\"-\")[2][:2]))\n",
    "\n",
    "    # 合并时间特征\n",
    "    df = pd.concat([df, ret_df], axis=1)\n",
    "\n",
    "    # 将日期转换为序号\n",
    "    unique_dates = pd.Series(df[\"Date\"].unique()).sort_values().reset_index(drop=True)\n",
    "    date_mapping = {date: rank + 1 for rank, date in enumerate(unique_dates)}\n",
    "    df[\"Date\"] = df[\"Date\"].map(date_mapping)\n",
    "\n",
    "    return df\n",
    "\n",
    "\n",
    "def processing_feature():\n",
    "    \"\"\"处理特征数据\"\"\"\n",
    "    # 读取训练数据\n",
    "    data = inputdata(TRAIN_DATA_PATH)\n",
    "\n",
    "    # 列名映射\n",
    "    column_mapping = {\n",
    "        \"股票代码\": \"StockCode\",\n",
    "        \"日期\": \"Date\",\n",
    "        \"开盘\": \"Open\",\n",
    "        \"收盘\": \"Close\",\n",
    "        \"最高\": \"High\",\n",
    "        \"最低\": \"Low\",\n",
    "        \"成交量\": \"Volume\",\n",
    "        \"成交额\": \"Turnover\",\n",
    "        \"振幅\": \"Amplitude\",\n",
    "        \"涨跌额\": \"PriceChange\",\n",
    "        \"换手率\": \"TurnoverRate\",\n",
    "        \"涨跌幅\": \"PriceChangePercentage\",\n",
    "    }\n",
    "\n",
    "    # 转换列名\n",
    "    data = transcolname(data, column_mapping)\n",
    "\n",
    "    # 删除涨跌幅列\n",
    "    data.drop(columns=[\"PriceChangePercentage\"], inplace=True)\n",
    "\n",
    "    # 日期特征转换\n",
    "    data = trans_datetime(data)\n",
    "\n",
    "    return data\n",
    "\n",
    "\n",
    "# 加载和处理特征数据\n",
    "print(\"正在加载和处理数据...\")\n",
    "feature = processing_feature()\n",
    "print(f\"数据形状: {feature.shape}\")\n",
    "print(f\"列名: {feature.columns.tolist()}\")\n",
    "print(f\"股票数量: {feature['StockCode'].nunique()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5113b7cb",
   "metadata": {},
   "source": [
    "## 构建模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5b7d2f76",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "IndRNN-LSTM模型参数配置:\n",
      "输入维度: 1\n",
      "IndRNN隐藏层大小: 256\n",
      "LSTM隐藏层大小: 512\n",
      "IndRNN层数: 2\n",
      "LSTM层数: 4\n",
      "Dropout率: 0.2\n"
     ]
    }
   ],
   "source": [
    "class IndRNNCell(nn.Module):\n",
    "    \"\"\"\n",
    "    Independent RNN Cell\n",
    "    IndRNN的核心思想是每个隐藏单元只依赖于自身的前一时刻状态和当前输入\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, input_size, hidden_size):\n",
    "        super(IndRNNCell, self).__init__()\n",
    "        self.input_size = input_size\n",
    "        self.hidden_size = hidden_size\n",
    "\n",
    "        # 输入到隐藏层的权重\n",
    "        self.weight_ih = nn.Parameter(torch.randn(hidden_size, input_size))\n",
    "        # 隐藏状态的递归权重（对角矩阵，每个神经元独立）\n",
    "        self.weight_hh = nn.Parameter(torch.randn(hidden_size))\n",
    "        # 偏置\n",
    "        self.bias = nn.Parameter(torch.randn(hidden_size))\n",
    "\n",
    "        self.reset_parameters()\n",
    "\n",
    "    def reset_parameters(self):\n",
    "        \"\"\"初始化参数\"\"\"\n",
    "        std = 1.0 / np.sqrt(self.hidden_size)\n",
    "        for weight in self.parameters():\n",
    "            weight.data.uniform_(-std, std)\n",
    "\n",
    "    def forward(self, input, hidden):\n",
    "        \"\"\"\n",
    "        前向传播\n",
    "        Args:\n",
    "            input: (batch_size, input_size)\n",
    "            hidden: (batch_size, hidden_size)\n",
    "        Returns:\n",
    "            new_hidden: (batch_size, hidden_size)\n",
    "        \"\"\"\n",
    "        # 计算输入部分：W_ih * x_t\n",
    "        input_part = torch.mm(input, self.weight_ih.t())\n",
    "\n",
    "        # 计算隐藏状态部分：W_hh * h_{t-1} (element-wise multiplication)\n",
    "        hidden_part = hidden * self.weight_hh\n",
    "\n",
    "        # 计算新的隐藏状态：tanh(W_ih * x_t + W_hh * h_{t-1} + b)\n",
    "        new_hidden = torch.tanh(input_part + hidden_part + self.bias)\n",
    "\n",
    "        return new_hidden\n",
    "\n",
    "\n",
    "class IndRNN(nn.Module):\n",
    "    \"\"\"\n",
    "    Independent RNN层\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, input_size, hidden_size, num_layers=1, dropout=0.0):\n",
    "        super(IndRNN, self).__init__()\n",
    "        self.input_size = input_size\n",
    "        self.hidden_size = hidden_size\n",
    "        self.num_layers = num_layers\n",
    "        self.dropout = dropout\n",
    "\n",
    "        # 创建多层IndRNN\n",
    "        self.cells = nn.ModuleList()\n",
    "        for i in range(num_layers):\n",
    "            layer_input_size = input_size if i == 0 else hidden_size\n",
    "            self.cells.append(IndRNNCell(layer_input_size, hidden_size))\n",
    "\n",
    "        # Dropout层\n",
    "        if dropout > 0:\n",
    "            self.dropout_layer = nn.Dropout(dropout)\n",
    "        else:\n",
    "            self.dropout_layer = None\n",
    "\n",
    "    def forward(self, input, hidden=None):\n",
    "        \"\"\"\n",
    "        前向传播\n",
    "        Args:\n",
    "            input: (batch_size, seq_len, input_size)\n",
    "            hidden: 初始隐藏状态\n",
    "        Returns:\n",
    "            output: (batch_size, seq_len, hidden_size)\n",
    "            hidden: 最终隐藏状态\n",
    "        \"\"\"\n",
    "        batch_size, seq_len, _ = input.size()\n",
    "\n",
    "        if hidden is None:\n",
    "            hidden = [\n",
    "                torch.zeros(batch_size, self.hidden_size).to(input.device)\n",
    "                for _ in range(self.num_layers)\n",
    "            ]\n",
    "\n",
    "        outputs = []\n",
    "\n",
    "        for t in range(seq_len):\n",
    "            x = input[:, t, :]\n",
    "\n",
    "            for layer in range(self.num_layers):\n",
    "                x = self.cells[layer](x, hidden[layer])\n",
    "                hidden[layer] = x\n",
    "\n",
    "                # 应用dropout（除了最后一层）\n",
    "                if self.dropout_layer is not None and layer < self.num_layers - 1:\n",
    "                    x = self.dropout_layer(x)\n",
    "\n",
    "            outputs.append(x)\n",
    "\n",
    "        # 堆叠输出\n",
    "        output = torch.stack(outputs, dim=1)\n",
    "\n",
    "        return output, hidden\n",
    "\n",
    "\n",
    "class IndRNNLSTMModel(nn.Module):\n",
    "    \"\"\"\n",
    "    IndRNN-LSTM混合模型\n",
    "    先使用IndRNN处理输入序列，然后使用LSTM进行进一步的时序建模\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        input_size,\n",
    "        indrnn_hidden_size,\n",
    "        lstm_hidden_size,\n",
    "        num_indrnn_layers=1,\n",
    "        num_lstm_layers=1,\n",
    "        output_size=1,\n",
    "        dropout=0.2,\n",
    "    ):\n",
    "        super(IndRNNLSTMModel, self).__init__()\n",
    "\n",
    "        self.input_size = input_size\n",
    "        self.indrnn_hidden_size = indrnn_hidden_size\n",
    "        self.lstm_hidden_size = lstm_hidden_size\n",
    "        self.num_indrnn_layers = num_indrnn_layers\n",
    "        self.num_lstm_layers = num_lstm_layers\n",
    "        self.output_size = output_size\n",
    "\n",
    "        # IndRNN层\n",
    "        self.indrnn = IndRNN(\n",
    "            input_size=input_size,\n",
    "            hidden_size=indrnn_hidden_size,\n",
    "            num_layers=num_indrnn_layers,\n",
    "            dropout=dropout,\n",
    "        )\n",
    "\n",
    "        # LSTM层\n",
    "        self.lstm = nn.LSTM(\n",
    "            input_size=indrnn_hidden_size,\n",
    "            hidden_size=lstm_hidden_size,\n",
    "            num_layers=num_lstm_layers,\n",
    "            batch_first=True,\n",
    "            dropout=dropout if num_lstm_layers > 1 else 0,\n",
    "        )\n",
    "\n",
    "        # 输出层\n",
    "        self.fc = nn.Linear(lstm_hidden_size, output_size)\n",
    "\n",
    "        # Dropout层\n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "\n",
    "    def forward(self, x):\n",
    "        \"\"\"\n",
    "        前向传播\n",
    "        Args:\n",
    "            x: (batch_size, seq_len, input_size)\n",
    "        Returns:\n",
    "            output: (batch_size, output_size)\n",
    "        \"\"\"\n",
    "        # IndRNN处理\n",
    "        indrnn_out, _ = self.indrnn(x)\n",
    "\n",
    "        # LSTM处理\n",
    "        lstm_out, _ = self.lstm(indrnn_out)\n",
    "\n",
    "        # 取最后一个时间步的输出\n",
    "        last_output = lstm_out[:, -1, :]\n",
    "\n",
    "        # Dropout\n",
    "        last_output = self.dropout(last_output)\n",
    "\n",
    "        # 全连接层输出\n",
    "        output = self.fc(last_output)\n",
    "\n",
    "        return output\n",
    "\n",
    "\n",
    "# 模型参数配置\n",
    "lstm_config = MODEL_PARAMS[\"LSTM\"]\n",
    "input_size = 1\n",
    "indrnn_hidden_size = 256  # IndRNN隐藏层大小\n",
    "lstm_hidden_size = lstm_config[\"hidden_size\"]  # LSTM隐藏层大小\n",
    "num_indrnn_layers = 2\n",
    "num_lstm_layers = lstm_config[\"num_layers\"]\n",
    "output_size = 1\n",
    "dropout = lstm_config[\"dropout\"]\n",
    "\n",
    "print(\"IndRNN-LSTM模型参数配置:\")\n",
    "print(f\"输入维度: {input_size}\")\n",
    "print(f\"IndRNN隐藏层大小: {indrnn_hidden_size}\")\n",
    "print(f\"LSTM隐藏层大小: {lstm_hidden_size}\")\n",
    "print(f\"IndRNN层数: {num_indrnn_layers}\")\n",
    "print(f\"LSTM层数: {num_lstm_layers}\")\n",
    "print(f\"Dropout率: {dropout}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "663c9e0f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "正在处理数据...\n",
      "总训练样本数: 626129\n",
      "总训练样本数: 626129\n",
      "训练集样本数: 500904\n",
      "验证集样本数: 125225\n",
      "训练集样本数: 500904\n",
      "验证集样本数: 125225\n",
      "开始训练IndRNN-LSTM模型...\n",
      "开始训练IndRNN-LSTM模型...\n",
      "Epoch [5/20]\n",
      "  训练损失: 7575.7995\n",
      "  验证损失: 7259.8933\n",
      "  验证MSE: 7261.1627\n",
      "  验证MAE: 31.4518\n",
      "  验证R²: -0.0000\n",
      "Epoch [5/20]\n",
      "  训练损失: 7575.7995\n",
      "  验证损失: 7259.8933\n",
      "  验证MSE: 7261.1627\n",
      "  验证MAE: 31.4518\n",
      "  验证R²: -0.0000\n",
      "Epoch [10/20]\n",
      "  训练损失: 7575.4423\n",
      "  验证损失: 7259.7090\n",
      "  验证MSE: 7260.9781\n",
      "  验证MAE: 31.5505\n",
      "  验证R²: -0.0000\n",
      "Epoch [10/20]\n",
      "  训练损失: 7575.4423\n",
      "  验证损失: 7259.7090\n",
      "  验证MSE: 7260.9781\n",
      "  验证MAE: 31.5505\n",
      "  验证R²: -0.0000\n",
      "Epoch [15/20]\n",
      "  训练损失: 7575.6324\n",
      "  验证损失: 7259.6781\n",
      "  验证MSE: 7260.9468\n",
      "  验证MAE: 31.5723\n",
      "  验证R²: -0.0000\n",
      "Epoch [15/20]\n",
      "  训练损失: 7575.6324\n",
      "  验证损失: 7259.6781\n",
      "  验证MSE: 7260.9468\n",
      "  验证MAE: 31.5723\n",
      "  验证R²: -0.0000\n",
      "Epoch [20/20]\n",
      "  训练损失: 7575.6968\n",
      "  验证损失: 7259.6464\n",
      "  验证MSE: 7260.9155\n",
      "  验证MAE: 31.5970\n",
      "  验证R²: -0.0000\n",
      "Epoch [20/20]\n",
      "  训练损失: 7575.6968\n",
      "  验证损失: 7259.6464\n",
      "  验证MSE: 7260.9155\n",
      "  验证MAE: 31.5970\n",
      "  验证R²: -0.0000\n",
      "模型已保存到: ../../model/indrnn_lstm_model_Close.bin\n",
      "模型已保存到: ../../model/indrnn_lstm_model_Close.bin\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\xiaof\\AppData\\Local\\Temp\\ipykernel_25880\\825990257.py:218: UserWarning: Glyph 35757 (\\N{CJK UNIFIED IDEOGRAPH-8BAD}) missing from font(s) DejaVu Sans.\n",
      "  plt.tight_layout()\n",
      "C:\\Users\\xiaof\\AppData\\Local\\Temp\\ipykernel_25880\\825990257.py:218: UserWarning: Glyph 32451 (\\N{CJK UNIFIED IDEOGRAPH-7EC3}) missing from font(s) DejaVu Sans.\n",
      "  plt.tight_layout()\n",
      "C:\\Users\\xiaof\\AppData\\Local\\Temp\\ipykernel_25880\\825990257.py:218: UserWarning: Glyph 36807 (\\N{CJK UNIFIED IDEOGRAPH-8FC7}) missing from font(s) DejaVu Sans.\n",
      "  plt.tight_layout()\n",
      "C:\\Users\\xiaof\\AppData\\Local\\Temp\\ipykernel_25880\\825990257.py:218: UserWarning: Glyph 31243 (\\N{CJK UNIFIED IDEOGRAPH-7A0B}) missing from font(s) DejaVu Sans.\n",
      "  plt.tight_layout()\n",
      "C:\\Users\\xiaof\\AppData\\Local\\Temp\\ipykernel_25880\\825990257.py:218: UserWarning: Glyph 25439 (\\N{CJK UNIFIED IDEOGRAPH-635F}) missing from font(s) DejaVu Sans.\n",
      "  plt.tight_layout()\n",
      "C:\\Users\\xiaof\\AppData\\Local\\Temp\\ipykernel_25880\\825990257.py:218: UserWarning: Glyph 22833 (\\N{CJK UNIFIED IDEOGRAPH-5931}) missing from font(s) DejaVu Sans.\n",
      "  plt.tight_layout()\n",
      "C:\\Users\\xiaof\\AppData\\Local\\Temp\\ipykernel_25880\\825990257.py:218: UserWarning: Glyph 21464 (\\N{CJK UNIFIED IDEOGRAPH-53D8}) missing from font(s) DejaVu Sans.\n",
      "  plt.tight_layout()\n",
      "C:\\Users\\xiaof\\AppData\\Local\\Temp\\ipykernel_25880\\825990257.py:218: UserWarning: Glyph 21270 (\\N{CJK UNIFIED IDEOGRAPH-5316}) missing from font(s) DejaVu Sans.\n",
      "  plt.tight_layout()\n",
      "C:\\Users\\xiaof\\AppData\\Local\\Temp\\ipykernel_25880\\825990257.py:218: UserWarning: Glyph 39564 (\\N{CJK UNIFIED IDEOGRAPH-9A8C}) missing from font(s) DejaVu Sans.\n",
      "  plt.tight_layout()\n",
      "C:\\Users\\xiaof\\AppData\\Local\\Temp\\ipykernel_25880\\825990257.py:218: UserWarning: Glyph 35777 (\\N{CJK UNIFIED IDEOGRAPH-8BC1}) missing from font(s) DejaVu Sans.\n",
      "  plt.tight_layout()\n",
      "C:\\Users\\xiaof\\AppData\\Local\\Temp\\ipykernel_25880\\825990257.py:218: UserWarning: Glyph 35823 (\\N{CJK UNIFIED IDEOGRAPH-8BEF}) missing from font(s) DejaVu Sans.\n",
      "  plt.tight_layout()\n",
      "C:\\Users\\xiaof\\AppData\\Local\\Temp\\ipykernel_25880\\825990257.py:218: UserWarning: Glyph 24046 (\\N{CJK UNIFIED IDEOGRAPH-5DEE}) missing from font(s) DejaVu Sans.\n",
      "  plt.tight_layout()\n",
      "C:\\Users\\xiaof\\AppData\\Local\\Temp\\ipykernel_25880\\825990257.py:218: UserWarning: Glyph 38598 (\\N{CJK UNIFIED IDEOGRAPH-96C6}) missing from font(s) DejaVu Sans.\n",
      "  plt.tight_layout()\n",
      "C:\\Users\\xiaof\\AppData\\Local\\Temp\\ipykernel_25880\\825990257.py:218: UserWarning: Glyph 21644 (\\N{CJK UNIFIED IDEOGRAPH-548C}) missing from font(s) DejaVu Sans.\n",
      "  plt.tight_layout()\n",
      "d:\\Python\\Projects\\TeamProjects\\大数据挑战赛\\.venv\\lib\\site-packages\\IPython\\core\\pylabtools.py:170: UserWarning: Glyph 35757 (\\N{CJK UNIFIED IDEOGRAPH-8BAD}) missing from font(s) DejaVu Sans.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "d:\\Python\\Projects\\TeamProjects\\大数据挑战赛\\.venv\\lib\\site-packages\\IPython\\core\\pylabtools.py:170: UserWarning: Glyph 32451 (\\N{CJK UNIFIED IDEOGRAPH-7EC3}) missing from font(s) DejaVu Sans.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "d:\\Python\\Projects\\TeamProjects\\大数据挑战赛\\.venv\\lib\\site-packages\\IPython\\core\\pylabtools.py:170: UserWarning: Glyph 36807 (\\N{CJK UNIFIED IDEOGRAPH-8FC7}) missing from font(s) DejaVu Sans.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "d:\\Python\\Projects\\TeamProjects\\大数据挑战赛\\.venv\\lib\\site-packages\\IPython\\core\\pylabtools.py:170: UserWarning: Glyph 31243 (\\N{CJK UNIFIED IDEOGRAPH-7A0B}) missing from font(s) DejaVu Sans.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "d:\\Python\\Projects\\TeamProjects\\大数据挑战赛\\.venv\\lib\\site-packages\\IPython\\core\\pylabtools.py:170: UserWarning: Glyph 25439 (\\N{CJK UNIFIED IDEOGRAPH-635F}) missing from font(s) DejaVu Sans.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "d:\\Python\\Projects\\TeamProjects\\大数据挑战赛\\.venv\\lib\\site-packages\\IPython\\core\\pylabtools.py:170: UserWarning: Glyph 22833 (\\N{CJK UNIFIED IDEOGRAPH-5931}) missing from font(s) DejaVu Sans.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "d:\\Python\\Projects\\TeamProjects\\大数据挑战赛\\.venv\\lib\\site-packages\\IPython\\core\\pylabtools.py:170: UserWarning: Glyph 21464 (\\N{CJK UNIFIED IDEOGRAPH-53D8}) missing from font(s) DejaVu Sans.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "d:\\Python\\Projects\\TeamProjects\\大数据挑战赛\\.venv\\lib\\site-packages\\IPython\\core\\pylabtools.py:170: UserWarning: Glyph 21270 (\\N{CJK UNIFIED IDEOGRAPH-5316}) missing from font(s) DejaVu Sans.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "d:\\Python\\Projects\\TeamProjects\\大数据挑战赛\\.venv\\lib\\site-packages\\IPython\\core\\pylabtools.py:170: UserWarning: Glyph 39564 (\\N{CJK UNIFIED IDEOGRAPH-9A8C}) missing from font(s) DejaVu Sans.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "d:\\Python\\Projects\\TeamProjects\\大数据挑战赛\\.venv\\lib\\site-packages\\IPython\\core\\pylabtools.py:170: UserWarning: Glyph 35777 (\\N{CJK UNIFIED IDEOGRAPH-8BC1}) missing from font(s) DejaVu Sans.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "d:\\Python\\Projects\\TeamProjects\\大数据挑战赛\\.venv\\lib\\site-packages\\IPython\\core\\pylabtools.py:170: UserWarning: Glyph 35823 (\\N{CJK UNIFIED IDEOGRAPH-8BEF}) missing from font(s) DejaVu Sans.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "d:\\Python\\Projects\\TeamProjects\\大数据挑战赛\\.venv\\lib\\site-packages\\IPython\\core\\pylabtools.py:170: UserWarning: Glyph 24046 (\\N{CJK UNIFIED IDEOGRAPH-5DEE}) missing from font(s) DejaVu Sans.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "d:\\Python\\Projects\\TeamProjects\\大数据挑战赛\\.venv\\lib\\site-packages\\IPython\\core\\pylabtools.py:170: UserWarning: Glyph 38598 (\\N{CJK UNIFIED IDEOGRAPH-96C6}) missing from font(s) DejaVu Sans.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "d:\\Python\\Projects\\TeamProjects\\大数据挑战赛\\.venv\\lib\\site-packages\\IPython\\core\\pylabtools.py:170: UserWarning: Glyph 21644 (\\N{CJK UNIFIED IDEOGRAPH-548C}) missing from font(s) DejaVu Sans.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x500 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "=== 最终模型评估结果 ===\n",
      "MSE (均方误差): 7260.915472\n",
      "MAE (平均绝对误差): 31.597015\n",
      "R² (决定系数): -0.000014\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\Python\\Projects\\TeamProjects\\大数据挑战赛\\.venv\\lib\\site-packages\\IPython\\core\\pylabtools.py:170: UserWarning: Glyph 39044 (\\N{CJK UNIFIED IDEOGRAPH-9884}) missing from font(s) DejaVu Sans.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "d:\\Python\\Projects\\TeamProjects\\大数据挑战赛\\.venv\\lib\\site-packages\\IPython\\core\\pylabtools.py:170: UserWarning: Glyph 27979 (\\N{CJK UNIFIED IDEOGRAPH-6D4B}) missing from font(s) DejaVu Sans.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "d:\\Python\\Projects\\TeamProjects\\大数据挑战赛\\.venv\\lib\\site-packages\\IPython\\core\\pylabtools.py:170: UserWarning: Glyph 20540 (\\N{CJK UNIFIED IDEOGRAPH-503C}) missing from font(s) DejaVu Sans.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "d:\\Python\\Projects\\TeamProjects\\大数据挑战赛\\.venv\\lib\\site-packages\\IPython\\core\\pylabtools.py:170: UserWarning: Glyph 27169 (\\N{CJK UNIFIED IDEOGRAPH-6A21}) missing from font(s) DejaVu Sans.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "d:\\Python\\Projects\\TeamProjects\\大数据挑战赛\\.venv\\lib\\site-packages\\IPython\\core\\pylabtools.py:170: UserWarning: Glyph 22411 (\\N{CJK UNIFIED IDEOGRAPH-578B}) missing from font(s) DejaVu Sans.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "d:\\Python\\Projects\\TeamProjects\\大数据挑战赛\\.venv\\lib\\site-packages\\IPython\\core\\pylabtools.py:170: UserWarning: Glyph 32467 (\\N{CJK UNIFIED IDEOGRAPH-7ED3}) missing from font(s) DejaVu Sans.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "d:\\Python\\Projects\\TeamProjects\\大数据挑战赛\\.venv\\lib\\site-packages\\IPython\\core\\pylabtools.py:170: UserWarning: Glyph 26524 (\\N{CJK UNIFIED IDEOGRAPH-679C}) missing from font(s) DejaVu Sans.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "d:\\Python\\Projects\\TeamProjects\\大数据挑战赛\\.venv\\lib\\site-packages\\IPython\\core\\pylabtools.py:170: UserWarning: Glyph 23454 (\\N{CJK UNIFIED IDEOGRAPH-5B9E}) missing from font(s) DejaVu Sans.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "d:\\Python\\Projects\\TeamProjects\\大数据挑战赛\\.venv\\lib\\site-packages\\IPython\\core\\pylabtools.py:170: UserWarning: Glyph 38469 (\\N{CJK UNIFIED IDEOGRAPH-9645}) missing from font(s) DejaVu Sans.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def process_data(npdf, stp=320):\n",
    "    \"\"\"处理时间序列数据，生成训练序列和标签\"\"\"\n",
    "    ret = []\n",
    "    for i in range(npdf.shape[0] - stp):\n",
    "        train_seq = npdf[i : i + stp]  # 前32天的数据作为输入序列\n",
    "        train_label = npdf[i + stp]  # 第33天的数据作为标签\n",
    "        train_seq = torch.FloatTensor(train_seq)\n",
    "        train_label = torch.FloatTensor(train_label).view(-1)\n",
    "        ret.append((train_seq, train_label))\n",
    "    return ret\n",
    "\n",
    "\n",
    "def create_train_test_split(train_data, test_ratio=0.2):\n",
    "    \"\"\"划分训练集和测试集\"\"\"\n",
    "    total_samples = len(train_data)\n",
    "    test_size = int(total_samples * test_ratio)\n",
    "\n",
    "    # 随机打乱数据\n",
    "    indices = np.random.permutation(total_samples)\n",
    "    test_indices = indices[:test_size]\n",
    "    train_indices = indices[test_size:]\n",
    "\n",
    "    train_set = [train_data[i] for i in train_indices]\n",
    "    test_set = [train_data[i] for i in test_indices]\n",
    "\n",
    "    return train_set, test_set\n",
    "\n",
    "\n",
    "def evaluate_model(model, test_loader, criterion, device):\n",
    "    \"\"\"评估模型性能\"\"\"\n",
    "    model.eval()\n",
    "    predictions = []\n",
    "    actuals = []\n",
    "    total_loss = 0.0\n",
    "\n",
    "    with torch.no_grad():\n",
    "        for batch_X, batch_y in test_loader:\n",
    "            batch_X, batch_y = batch_X.to(device), batch_y.to(device)\n",
    "\n",
    "            outputs = model(batch_X)\n",
    "            loss = criterion(outputs, batch_y.unsqueeze(1))\n",
    "            total_loss += loss.item()\n",
    "\n",
    "            predictions.extend(outputs.cpu().numpy().flatten())\n",
    "            actuals.extend(batch_y.cpu().numpy().flatten())\n",
    "\n",
    "    # 计算评估指标\n",
    "    mse = mean_squared_error(actuals, predictions)\n",
    "    mae = mean_absolute_error(actuals, predictions)\n",
    "    r2 = r2_score(actuals, predictions)\n",
    "\n",
    "    return {\n",
    "        \"loss\": total_loss / len(test_loader),\n",
    "        \"mse\": mse,\n",
    "        \"mae\": mae,\n",
    "        \"r2\": r2,\n",
    "        \"predictions\": predictions,\n",
    "        \"actuals\": actuals,\n",
    "    }\n",
    "\n",
    "\n",
    "# 数据预处理\n",
    "print(\"正在处理数据...\")\n",
    "column_names = feature.columns.tolist()\n",
    "stockcodes = feature[\"StockCode\"].drop_duplicates().tolist()\n",
    "colname2index = {x: i for i, x in enumerate(column_names)}\n",
    "\n",
    "# 为每支股票生成训练数据\n",
    "train_data = []\n",
    "for stockcode in stockcodes:\n",
    "    stock_data = feature[feature[\"StockCode\"] == stockcode]\n",
    "    stock_data = stock_data.values\n",
    "\n",
    "    if len(stock_data) < 32:\n",
    "        continue\n",
    "\n",
    "    train_data += process_data(stock_data, stp=32)\n",
    "\n",
    "print(f\"总训练样本数: {len(train_data)}\")\n",
    "\n",
    "# 划分训练集和验证集\n",
    "train_set, val_set = create_train_test_split(train_data, test_ratio=0.2)\n",
    "print(f\"训练集样本数: {len(train_set)}\")\n",
    "print(f\"验证集样本数: {len(val_set)}\")\n",
    "\n",
    "\n",
    "# 训练模型\n",
    "def train_indrnn_lstm_model(train_data, val_data, target_col_index, num_epochs=None):\n",
    "    \"\"\"训练IndRNN-LSTM模型\"\"\"\n",
    "    training_config = TRAINING_PARAMS\n",
    "\n",
    "    if num_epochs is None:\n",
    "        num_epochs = training_config[\"num_epochs\"]\n",
    "\n",
    "    if len(train_data) == 0:\n",
    "        return None\n",
    "\n",
    "    # 将数据移动到设备\n",
    "    train_data = [(x.to(device), y.to(device)) for x, y in train_data]\n",
    "    val_data = [(x.to(device), y.to(device)) for x, y in val_data]\n",
    "\n",
    "    # 构建训练数据张量\n",
    "    X_train_tensor = torch.stack([x for x, _ in train_data])\n",
    "    y_train_tensor = torch.stack([y[target_col_index] for _, y in train_data])\n",
    "\n",
    "    X_val_tensor = torch.stack([x for x, _ in val_data])\n",
    "    y_val_tensor = torch.stack([y[target_col_index] for _, y in val_data])\n",
    "\n",
    "    # 创建数据加载器\n",
    "    train_dataset = TensorDataset(X_train_tensor, y_train_tensor)\n",
    "    val_dataset = TensorDataset(X_val_tensor, y_val_tensor)\n",
    "\n",
    "    train_loader = DataLoader(\n",
    "        train_dataset, batch_size=training_config[\"batch_size\"], shuffle=True\n",
    "    )\n",
    "    val_loader = DataLoader(\n",
    "        val_dataset, batch_size=training_config[\"batch_size\"], shuffle=False\n",
    "    )\n",
    "\n",
    "    # 初始化模型\n",
    "    model = IndRNNLSTMModel(\n",
    "        input_size=len(train_data[0][0][0]),\n",
    "        indrnn_hidden_size=indrnn_hidden_size,\n",
    "        lstm_hidden_size=lstm_hidden_size,\n",
    "        num_indrnn_layers=num_indrnn_layers,\n",
    "        num_lstm_layers=num_lstm_layers,\n",
    "        output_size=output_size,\n",
    "        dropout=dropout,\n",
    "    ).to(device)\n",
    "\n",
    "    # 定义损失函数和优化器\n",
    "    criterion = nn.MSELoss()\n",
    "    optimizer = optim.Adam(model.parameters(), lr=training_config[\"learning_rate\"])\n",
    "    scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.7)\n",
    "\n",
    "    # 记录训练过程\n",
    "    train_losses = []\n",
    "    val_losses = []\n",
    "    val_metrics = []\n",
    "\n",
    "    print(\"开始训练IndRNN-LSTM模型...\")\n",
    "    for epoch in range(num_epochs):\n",
    "        # 训练阶段\n",
    "        model.train()\n",
    "        train_loss = 0.0\n",
    "        for batch_X, batch_y in train_loader:\n",
    "            optimizer.zero_grad()\n",
    "\n",
    "            outputs = model(batch_X)\n",
    "            loss = criterion(outputs, batch_y.unsqueeze(1))\n",
    "            train_loss += loss.item()\n",
    "\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "\n",
    "        # 验证阶段\n",
    "        val_results = evaluate_model(model, val_loader, criterion, device)\n",
    "\n",
    "        train_losses.append(train_loss / len(train_loader))\n",
    "        val_losses.append(val_results[\"loss\"])\n",
    "        val_metrics.append(val_results)\n",
    "\n",
    "        scheduler.step()\n",
    "\n",
    "        if (epoch + 1) % 5 == 0:\n",
    "            print(f\"Epoch [{epoch+1}/{num_epochs}]\")\n",
    "            print(f\"  训练损失: {train_losses[-1]:.4f}\")\n",
    "            print(f\"  验证损失: {val_results['loss']:.4f}\")\n",
    "            print(f\"  验证MSE: {val_results['mse']:.4f}\")\n",
    "            print(f\"  验证MAE: {val_results['mae']:.4f}\")\n",
    "            print(f\"  验证R²: {val_results['r2']:.4f}\")\n",
    "\n",
    "    return model, train_losses, val_losses, val_metrics\n",
    "\n",
    "\n",
    "# 训练Close价格预测模型\n",
    "close_col_index = (\n",
    "    colname2index[\"Close\"] + 2\n",
    ")  # +2是因为前面有StockCode和Date列的位置调整\n",
    "model, train_losses, val_losses, val_metrics = train_indrnn_lstm_model(\n",
    "    train_set, val_set, close_col_index, num_epochs=20\n",
    ")\n",
    "\n",
    "# 保存模型\n",
    "model_name = f\"{MODEL_DIR}/indrnn_lstm_model_Close.bin\"\n",
    "pickle.dump(model, open(model_name, \"wb\"))\n",
    "print(f\"模型已保存到: {model_name}\")\n",
    "\n",
    "# 可视化训练过程\n",
    "plt.figure(figsize=(15, 5))\n",
    "\n",
    "plt.subplot(1, 3, 1)\n",
    "plt.plot(train_losses, label=\"训练损失\")\n",
    "plt.plot(val_losses, label=\"验证损失\")\n",
    "plt.title(\"训练过程损失变化\")\n",
    "plt.xlabel(\"Epoch\")\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.legend()\n",
    "\n",
    "plt.subplot(1, 3, 2)\n",
    "mse_values = [m[\"mse\"] for m in val_metrics]\n",
    "mae_values = [m[\"mae\"] for m in val_metrics]\n",
    "plt.plot(mse_values, label=\"MSE\")\n",
    "plt.plot(mae_values, label=\"MAE\")\n",
    "plt.title(\"验证集MSE和MAE变化\")\n",
    "plt.xlabel(\"Epoch\")\n",
    "plt.ylabel(\"误差\")\n",
    "plt.legend()\n",
    "\n",
    "plt.subplot(1, 3, 3)\n",
    "r2_values = [m[\"r2\"] for m in val_metrics]\n",
    "plt.plot(r2_values, label=\"R²\")\n",
    "plt.title(\"验证集R²变化\")\n",
    "plt.xlabel(\"Epoch\")\n",
    "plt.ylabel(\"R²\")\n",
    "plt.legend()\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "# 输出最终评估结果\n",
    "final_metrics = val_metrics[-1]\n",
    "print(\"\\n=== 最终模型评估结果 ===\")\n",
    "print(f\"MSE (均方误差): {final_metrics['mse']:.6f}\")\n",
    "print(f\"MAE (平均绝对误差): {final_metrics['mae']:.6f}\")\n",
    "print(f\"R² (决定系数): {final_metrics['r2']:.6f}\")\n",
    "\n",
    "# 预测结果散点图\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.scatter(final_metrics[\"actuals\"], final_metrics[\"predictions\"], alpha=0.5)\n",
    "plt.plot(\n",
    "    [min(final_metrics[\"actuals\"]), max(final_metrics[\"actuals\"])],\n",
    "    [min(final_metrics[\"actuals\"]), max(final_metrics[\"actuals\"])],\n",
    "    \"r--\",\n",
    "    lw=2,\n",
    ")\n",
    "plt.xlabel(\"实际值\")\n",
    "plt.ylabel(\"预测值\")\n",
    "plt.title(\"IndRNN-LSTM模型预测结果 vs 实际值\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "803cda25",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "正在进行测试数据预测...\n",
      "测试数据股票数量: 300\n",
      "测试数据股票数量: 300\n",
      "IndRNN-LSTM模型加载成功\n",
      "IndRNN-LSTM模型加载成功\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\Python\\Projects\\TeamProjects\\大数据挑战赛\\.venv\\lib\\site-packages\\torch\\nn\\modules\\rnn.py:917: UserWarning: RNN module weights are not part of single contiguous chunk of memory. This means they need to be compacted at every call, possibly greatly increasing memory usage. To compact weights again call flatten_parameters(). (Triggered internally at C:\\actions-runner\\_work\\pytorch\\pytorch\\builder\\windows\\pytorch\\aten\\src\\ATen\\native\\cudnn\\RNN.cpp:1424.)\n",
      "  result = _VF.lstm(input, hx, self._flat_weights, self.bias, self.num_layers,\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "=== 预测结果 ===\n",
      "涨幅最大的前10支股票:\n",
      " 1. 600010: +1702.26%\n",
      " 2. 601868: +1340.19%\n",
      " 3. 601618: +993.57%\n",
      " 4. 601916: +971.77%\n",
      " 5. 630: +920.90%\n",
      " 6. 600219: +829.69%\n",
      " 7. 600515: +813.89%\n",
      " 8. 3816: +813.89%\n",
      " 9. 600115: +767.21%\n",
      "10. 601818: +746.73%\n",
      "\n",
      "涨幅最小的后10支股票:\n",
      " 1. 300760: -85.13%\n",
      " 2. 300750: -86.37%\n",
      " 3. 300033: -87.60%\n",
      " 4. 688506: -88.35%\n",
      " 5. 605499: -88.39%\n",
      " 6. 688111: -88.67%\n",
      " 7. 2594: -91.30%\n",
      " 8. 2371: -92.88%\n",
      " 9. 688256: -95.32%\n",
      "10. 600519: -97.92%\n",
      "\n",
      "结果已保存到: ../../output/indrnn_lstm_result.csv\n",
      "详细预测结果已保存到: ../../output/indrnn_lstm_detailed_predictions.csv\n",
      "\n",
      "=== 预测统计信息 ===\n",
      "成功预测的股票数量: 298\n",
      "平均预测涨跌幅: 143.27%\n",
      "预测涨跌幅标准差: 244.48%\n",
      "最大预测涨幅: 1702.26%\n",
      "最大预测跌幅: -97.92%\n"
     ]
    }
   ],
   "source": [
    "# 测试数据预测\n",
    "def processing_feature_test():\n",
    "    \"\"\"测试数据特征处理函数\"\"\"\n",
    "    # 读取测试数据\n",
    "    data = inputdata(TEST_DATA_PATH)\n",
    "\n",
    "    # 列名映射\n",
    "    column_mapping = {\n",
    "        \"股票代码\": \"StockCode\",\n",
    "        \"日期\": \"Date\",\n",
    "        \"开盘\": \"Open\",\n",
    "        \"收盘\": \"Close\",\n",
    "        \"最高\": \"High\",\n",
    "        \"最低\": \"Low\",\n",
    "        \"成交量\": \"Volume\",\n",
    "        \"成交额\": \"Turnover\",\n",
    "        \"振幅\": \"Amplitude\",\n",
    "        \"涨跌额\": \"PriceChange\",\n",
    "        \"换手率\": \"TurnoverRate\",\n",
    "        \"涨跌幅\": \"PriceChangePercentage\",\n",
    "    }\n",
    "\n",
    "    # 转换列名\n",
    "    data = transcolname(data, column_mapping)\n",
    "\n",
    "    # 删除涨跌幅列\n",
    "    data.drop(columns=[\"PriceChangePercentage\"], inplace=True)\n",
    "\n",
    "    # 日期特征转换\n",
    "    data = trans_datetime(data)\n",
    "\n",
    "    # 只保留最近32天的数据用于预测\n",
    "    pred_len = 32\n",
    "    max_date = data[\"Date\"].max()\n",
    "    data = data[data[\"Date\"] > max_date - pred_len]\n",
    "\n",
    "    return data\n",
    "\n",
    "\n",
    "def process_data_predict(data, stockcode):\n",
    "    \"\"\"为单支股票准备预测数据\"\"\"\n",
    "    # 筛选单支股票的数据\n",
    "    data = data[data[\"StockCode\"] == stockcode]\n",
    "    data = np.array([data.values])\n",
    "    return torch.tensor(data, dtype=torch.float32).to(device)\n",
    "\n",
    "\n",
    "print(\"正在进行测试数据预测...\")\n",
    "\n",
    "# 处理测试数据\n",
    "test_data = processing_feature_test()\n",
    "max_date = test_data[\"Date\"].max()\n",
    "test_stockcodes = test_data[\"StockCode\"].drop_duplicates().tolist()\n",
    "\n",
    "print(f\"测试数据股票数量: {len(test_stockcodes)}\")\n",
    "\n",
    "# 加载训练好的模型\n",
    "model_name = f\"{MODEL_DIR}/indrnn_lstm_model_Close.bin\"\n",
    "try:\n",
    "    trained_model = pickle.load(open(model_name, \"rb\"))\n",
    "    trained_model.eval()\n",
    "    print(\"IndRNN-LSTM模型加载成功\")\n",
    "except:\n",
    "    print(\"使用当前训练的模型进行预测\")\n",
    "    trained_model = model\n",
    "    trained_model.eval()\n",
    "\n",
    "# 对每支股票进行预测\n",
    "all_preds = []\n",
    "prediction_details = []\n",
    "\n",
    "with torch.no_grad():\n",
    "    for stockcode in test_stockcodes:\n",
    "        # 准备预测数据\n",
    "        predict_data = process_data_predict(test_data, stockcode)\n",
    "\n",
    "        if predict_data.shape[1] < 32:  # 如果数据不够32天，跳过\n",
    "            continue\n",
    "\n",
    "        # 进行预测\n",
    "        pred = trained_model(predict_data)\n",
    "        pred_value = pred.cpu().numpy()[0][0]\n",
    "\n",
    "        # 获取该股票当前的收盘价\n",
    "        current_close = test_data[\n",
    "            (test_data[\"StockCode\"] == stockcode) & (test_data[\"Date\"] == max_date)\n",
    "        ][\"Close\"].values\n",
    "\n",
    "        if len(current_close) > 0:\n",
    "            current_close = current_close[0]\n",
    "            # 计算预测涨跌幅\n",
    "            price_change_rate = (pred_value - current_close) / current_close * 100\n",
    "\n",
    "            all_preds.append((stockcode, price_change_rate))\n",
    "            prediction_details.append(\n",
    "                {\n",
    "                    \"股票代码\": stockcode,\n",
    "                    \"当前收盘价\": current_close,\n",
    "                    \"预测收盘价\": pred_value,\n",
    "                    \"预测涨跌幅(%)\": price_change_rate,\n",
    "                }\n",
    "            )\n",
    "\n",
    "# 按涨跌幅排序\n",
    "all_preds = sorted(all_preds, key=lambda x: x[1], reverse=True)\n",
    "\n",
    "# 获取涨幅最大的前10支股票和涨幅最小的后10支股票\n",
    "pred_top_10_max_target = [x[0] for x in all_preds[:10]]\n",
    "pred_top_10_min_target = [x[0] for x in all_preds[-10:]]\n",
    "\n",
    "print(\"\\n=== 预测结果 ===\")\n",
    "print(\"涨幅最大的前10支股票:\")\n",
    "for i, (code, rate) in enumerate(all_preds[:10], 1):\n",
    "    print(f\"{i:2d}. {code}: {rate:+.2f}%\")\n",
    "\n",
    "print(\"\\n涨幅最小的后10支股票:\")\n",
    "for i, (code, rate) in enumerate(all_preds[-10:], 1):\n",
    "    print(f\"{i:2d}. {code}: {rate:+.2f}%\")\n",
    "\n",
    "# 保存详细预测结果\n",
    "detail_df = pd.DataFrame(prediction_details)\n",
    "detail_df.to_csv(f\"{OUTPUT_DIR}/indrnn_lstm_detailed_predictions.csv\", index=False)\n",
    "\n",
    "# 构建并保存最终结果\n",
    "result_data = {\n",
    "    \"涨幅最大股票代码\": pred_top_10_max_target,\n",
    "    \"涨幅最小股票代码\": pred_top_10_min_target,\n",
    "}\n",
    "\n",
    "result_df = pd.DataFrame(result_data)\n",
    "result_path = f\"{OUTPUT_DIR}/indrnn_lstm_result.csv\"\n",
    "result_df.to_csv(result_path, index=False)\n",
    "\n",
    "print(f\"\\n结果已保存到: {result_path}\")\n",
    "print(f\"详细预测结果已保存到: {OUTPUT_DIR}/indrnn_lstm_detailed_predictions.csv\")\n",
    "\n",
    "# 显示预测统计信息\n",
    "print(f\"\\n=== 预测统计信息 ===\")\n",
    "print(f\"成功预测的股票数量: {len(all_preds)}\")\n",
    "print(f\"平均预测涨跌幅: {np.mean([x[1] for x in all_preds]):.2f}%\")\n",
    "print(f\"预测涨跌幅标准差: {np.std([x[1] for x in all_preds]):.2f}%\")\n",
    "print(f\"最大预测涨幅: {max([x[1] for x in all_preds]):.2f}%\")\n",
    "print(f\"最大预测跌幅: {min([x[1] for x in all_preds]):.2f}%\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
